package com.motong.gongdan.util;

import cn.hutool.core.io.IoUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.motong.gongdan.entity.CustomField;
import com.motong.gongdan.service.CustomFieldService;
import com.motong.gongdan.vo.system.otherVo.CustomFieldVo;
import io.swagger.annotations.ApiModel;
import lombok.Data;
import org.springframework.util.StringUtils;

import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.stream.Collectors;

@SuppressWarnings("all")
@ApiModel("表格列工具类")
@Data
public class ColumnUtils {

    // 自定义字段列表
    public final List<CustomField> customFieldList;

    // 基础字段中文英文映射列表
    public static Map<String, Map<String, String>> BASE_COLUMN_CN_EN_MAP = new HashMap<>();

    // 基础字段英文中文映射列表
    public static Map<String, Map<String, String>> BASE_COLUMN_EN_CN_MAP = new HashMap<>();


    // 基础字段中文列表
    public static Map<String, List<String>> BASE_COLUMN_CN_LIST = new HashMap<>();


    // 自定义列中文:id映射
    private Map<String, Integer> cnIdMap = new HashMap<>();

    // 自定义列id:自定义字段类映射
    private Map<Integer, CustomField> cuIdDataMap = new HashMap<>();

    // 自定义列中文:自定义字段类映射
    private Map<String, CustomField> cuCnDataMap = new HashMap<>();

    // 自定义字段id:value值映射
    private Map<Integer, String> customIdValueMap = new HashMap<>();

    // 自定义服务类
    private CustomFieldService customFieldService;

    static {
        //初始化所有固定字段 并存储 中:英  英:中 映射
        String read = IoUtil.read(ColumnUtils.class.getClassLoader().getResourceAsStream("columns.txt"), StandardCharsets.UTF_8);
        JSONArray columnList = JSONUtil.parseArray(read);
        columnList.forEach(i -> {
            if (i instanceof Map) {
                Map<String, Object> item = (Map<String, Object>) i;
                List<Map<String, Object>> columns = (List<Map<String, Object>>) item.get("columns");
                Map<String, String> cnEnMap = new LinkedHashMap<>();
                Map<String, String> enCnMap = new LinkedHashMap<>();
                List<String> cnNames = new ArrayList<>();
                columns.forEach(d -> {
                    String chineseName = d.getOrDefault("chineseName", "").toString();
                    String name = d.getOrDefault("name", "").toString();
                    if (StringUtils.hasLength(chineseName) && StringUtils.hasLength(name)) {
                        cnEnMap.put(chineseName, name);
                        enCnMap.put(name, chineseName);
                        cnNames.add(chineseName);
                    }
                });
                BASE_COLUMN_CN_EN_MAP.put(item.get("type").toString(), cnEnMap);
                BASE_COLUMN_EN_CN_MAP.put(item.get("type").toString(), enCnMap);
                BASE_COLUMN_CN_LIST.put(item.get("type").toString(), cnNames);
            }
        });
    }


    /**
     * 初始化获取某一表单所有自定义列
     *
     * @param customFieldService 自定义列服务
     * @param types              表单对应的类型(多个以,号隔开)
     */
    public ColumnUtils(CustomFieldService customFieldService, String types) {
        List<String> typeList = Arrays.stream(types.split(",")).filter(StringUtils::hasLength).collect(Collectors.toList());
        customFieldList = customFieldService.list(new LambdaQueryWrapper<CustomField>().in(CustomField::getFieldAscription, typeList));
        customFieldList.forEach(i -> {
            cnIdMap.put(i.getChineseName(), i.getId());
            cuIdDataMap.put(i.getId(), i);
            cuCnDataMap.put(i.getChineseName(), i);
        });
    }

    /**
     * 根据中文名称获取自定义字段
     *
     * @param chineseName 自定中文名称
     */
    public CustomField getCustomFieldByCn(String chineseName) {
        return cuCnDataMap.getOrDefault(chineseName, new CustomField());
    }

    /**
     * 提取给定数据的自定义列，并返回自定义列的相关属性
     *
     * @param cnDataMap 数据
     * @return 自定义列相关属性和值
     */
    public List<CustomFieldVo> cnGetCuColumnsString(Map<String, Object> cnDataMap) {
        if (customFieldList.isEmpty()) {
            return null;
        }
        List<CustomFieldVo> data = new ArrayList<>();
        customFieldList.forEach(i -> data.add(new CustomFieldVo().setCustomFieldId(i.getId()).setCustomFieldMess(i).setName(i.getChineseName())
                .setValue(Optional.ofNullable(cnDataMap.get(i.getChineseName())).orElse("").toString())));
        return data;
    }

    /**
     * 解析自定义json字符串获取自定义属性列表
     *
     * @param JsonArrayString 自定义字段json数组字符串
     * @return 自定义列相关属性和值
     */
    public List<CustomFieldVo> getCuColumnsByJsonArray(String JsonArrayString) {
        List<CustomFieldVo> data = Collections.emptyList();
        if (!StringUtils.hasLength(JsonArrayString) || Objects.isNull(this.cuIdDataMap)) {
            return data;
        }
        data = JSONUtil.toList(JsonArrayString, CustomFieldVo.class);
        data.forEach(i -> {
            i.setCustomFieldMess(this.cuIdDataMap.get(i.getCustomFieldId()))
                    .setName(this.cuIdDataMap.getOrDefault(i.getCustomFieldId(), new CustomField()).getChineseName());
            customIdValueMap.put(i.getCustomFieldId(), i.getValue());
        });
        return data;
    }


    /**
     * 解析自定义json字符串获取自定义属性列表
     *
     * @param cuIdData        自定义字段id数据的映射
     * @param JsonArrayString 自定义字段jsonsh数组字符串
     * @return 自定义列相关属性和值
     */
    public static List<CustomFieldVo> getCuColumnsByJsonArray(Map<Integer, CustomField> cuIdData, String JsonArrayString) {
        List<CustomFieldVo> data = Collections.emptyList();
        if (!StringUtils.hasLength(JsonArrayString) || Objects.isNull(cuIdData)) {
            return data;
        }
        data = JSONUtil.toList(JsonArrayString, CustomFieldVo.class);
        data.forEach(i -> i.setCustomFieldMess(cuIdData.get(i.getCustomFieldId()))
                .setName(cuIdData.getOrDefault(i.getCustomFieldId(), new CustomField()).getChineseName()));
        return data;
    }

    public List<CustomField> getCustomFieldList() {
        return customFieldList;
    }
}
